/**
 * @Copyright ®2015 Sinosoft Co. Ltd. All rights reserved.<br/>
 * 项目名称 : 电子商务云服务平台
 * 创建日期 : 2016年6月28日
 * 修改历史 : 
 *     1. [2016年6月30日]修改文件 by chihouliang
 * 添加Javadoc注释，更新代码规范，静态工具类增加private构造函数，增加logger日志
 */
package com.gavinwind.inspay.common.util;


import com.gavinwind.inspay.common.logger.PlatformLogger;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;


/**
 * 日期工具类
 * 
 * @cDate 2010-11-23
 * @since JDK 1.5
 * @author dingkui
 * @version 1.0
 * 
 */
public class DateUtil {

    /**日志*/
    private static PlatformLogger logger = PlatformLogger.getLogger(HttpClientUtil.class);

    private DateUtil() {}

    /**
     * 默认的日期格式组合，用来将字符串转化为日期用
     * 
     */
    private static final String[] DATE_PARSE_PATTERNS = { "yyyy-MM-dd", "yyyy/MM/dd", "yyyy年MM月dd日", "yyyy-MM-dd hh:mm:ss", "yyyyMMddhhmmss",
            "yyyyMMdd" };

    /**
     * 默认的时间格式
     */
    private static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";

    /**
     * 默认的日期格式
     */
    private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";

    /**
     * 日期代码，周日
     */
    public static final int SUNDAY = 1;

    /**
     * 日期代码，周一
     */
    public static final int MONDAY = 2;

    /**
     * 日期代码，周二
     */
    public static final int TUESDAY = 3;

    /**
     * 日期代码，周三
     */
    public static final int WEDNESDAY = 4;

    /**
     * 日期代码，周四
     */
    public static final int THURSDAY = 5;

    /**
     * 日期代码，周五
     */
    public static final int FRIDAY = 6;

    /**
     * 日期代码，周六
     */
    public static final int SATURDAY = 7;

    /**
     * 日期精度，秒
     */
    public static final int ACCURACY_SECOND = 1;

    /**
     * 日期精度，分
     */
    public static final int ACCURACY_MINUTE = 2;

    /**
     * 日期精度，小时
     */
    public static final int ACCURACY_HOUR = 3;

    /**
     * 日期精度，天
     */
    public static final int ACCURACY_DAY = 4;

    /**
     * 日期精度，月
     */
    public static final int ACCURACY_MONTH = 5;

    /**
     * 日期精度，年
     */
    public static final int ACCURACY_YEAR = 6;

    /**
     * 比较用日期格式，精度为年
     */
    private static final String ACCURACY_PATTERN_YEAR = "yyyy";

    /**
     * 比较用日期格式，精度为月
     */
    private static final String ACCURACY_PATTERN_MONTH = "yyyyMM";

    /**
     * 比较用日期格式，精度为日
     */
    private static final String ACCURACY_PATTERN_DAY = "yyyyMMdd";

    /**
     * 比较用日期格式，精度为时
     */
    private static final String ACCURACY_PATTERN_HOUR = "yyyyMMddHH";

    /**
     * 比较用日期格式，精度为分
     */
    private static final String ACCURACY_PATTERN_MINUTE = "yyyyMMddHHmm";

    /**
     * 比较用日期格式，精度为秒
     */
    private static final String ACCURACY_PATTERN_SECOND = "yyyyMMddHHmmss";

    /**
     * 单一属性格式，时
     */
    private static final String SINGLE_YEAR = "yyyy";

    /**
     * 单一属性格式，时
     */
    private static final String SINGLE_MONTH = "M";

    /**
     * 单一属性格式，时
     */
    private static final String SINGLE_DAY = "d";

    /**
     * 单一属性格式，时
     */
    private static final String SINGLE_HOUR = "H";

    /**
     * 单一属性格式，分
     */
    private static final String SINGLE_MINUTE = "m";

    /**
     * 单一属性格式，秒
     */
    private static final String SINGLE_SECOND = "s";

    /**
     * 
     */
    private static final long MILLISECONDS_PER_SECOND = 1000;

    /**
     * 
     */
    private static final long MILLISECONDS_PER_MINUTE = 1000 * 60;

    /**
     * 
     */
    private static final long MILLISECONDS_PER_HOUR = 1000 * 60 * 60;

    /**
     * 
     */
    private static final long MILLISECONDS_PER_DAY = 1000 * 60 * 60 * 24;

    /**
     * 将给定的日期字符串，按照预定的日期格式，转化为Date型数据。目前支持的日期格式有，如下<br/>
     * <pre>
     *  yyyy-MM-dd //2012-12-12
     *  yyyy/MM/dd //2012/12/12
     *  yyyy年MM月dd日 //2012年12月12日
     *  yyyy-MM-dd hh:mm:ss //2012-12-12 12:12:12
     *  yyyyMMdd //20121212
     * </pre>
     * 例如：
     * 
     * @param cDateStr 日期字符串，所支持的格式在描述中。例如：2012-12-12
     * @return 日期型结果（java.util.Date）
     */
    public static Date parseDate(String cDateStr) {
        Date tDate = null;
        try {
            tDate = org.apache.commons.lang.time.DateUtils.parseDate(cDateStr, DATE_PARSE_PATTERNS);
        } catch (ParseException e) {
            logger.error("DateUtil系统异常:",e);
        }
        return tDate;
    }

    /**
     * 根据指定格式转化String型日期到Date型
     * 
     * @param cDateStr String型日期，如：2012-12-12
     * @param cParsePattern 指定的格式，与日期一直。如：yyyy-MM-dd
     * @return 日期型结果（java.util.Date）
     */
    public static Date parseDate(String cDateStr, String cParsePattern) {
        Date tDate = null;
        try {
            tDate = org.apache.commons.lang.time.DateUtils.parseDate(cDateStr, new String[] { cParsePattern.toString() });
        } catch (ParseException e) {
            logger.error("DateUtil系统异常:",e);
        }
        return tDate;
    }

    /**
     * 返回系统当前时间（Date型）
     * 
     * @return 系统当前时间
     */
    public static Date getCurrentDate() {
        return new Date();
    }
    

    /**
     * 按照strFormat格式输出当前时间
     * 
     * @param cStrFormat
     *      格式
     * @return 指定格式的当前系统日期
     */
    public static String getCurrentDate(String cStrFormat) {
        return getDateStr(getCurrentDate(), cStrFormat);
    }

    /**
     * 日期计算，日加减。如果想得到指定日期的第二天日期，第二个参数传入1；如果想得到指定日期的前一天日期，第二个参数传入-1
     * 
     * @param cDate 初始日期
     * @param cAmount 天数增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addDays(Date cDate, int cAmount) {
        Calendar tCalendar = Calendar.getInstance();
        tCalendar.setTime(cDate);
        tCalendar.add(Calendar.DATE, cAmount);//增加一天   
        return tCalendar.getTime();
    }

    /**
     * 日期计算，周加减。
     * 
     * @param cDate 初始日期
     * @param cAmount 周数增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addWeeks(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addWeeks(cDate, cAmount);
    }

    /**
     * 日期计算，月加减
     * 
     * @param cDate 初始日期
     * @param cAmount 月数增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addMonths(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addMonths(cDate, cAmount);
    }

    /**
     * 日期计算，年加减
     * 
     * @param cDate 初始日期
     * @param cAmount 年数增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addYears(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addYears(cDate, cAmount);
    }

    /**
     * 日期计算，小时加减
     * 
     * @param cDate 初始日期
     * @param cAmount 小时增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addHours(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addHours(cDate, cAmount);
    }

    /**
     * 日期计算，分钟加减
     * 
     * @param cDate 初始日期
     * @param cAmount 分钟增量（负数为减）
     * @return 计算后的日期（java.util.Date）
     */
    public static Date addMinutes(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addMinutes(cDate, cAmount);
    }

    /**
     * 日期计算，秒加减
     * 
     * @param cDate 初始日期
     * @param cAmount 秒增量（负数为减）
     * @return 计算后的日期
     */
    public static Date addSeconds(Date cDate, int cAmount) {
        return org.apache.commons.lang.time.DateUtils.addSeconds(cDate, cAmount);
    }

    /**
     * 根据指定格式，返回字符串类型日期时间
     * 
     * @param cDate 日期(java.util.Date)
     * @param cPattern 日期格式，支持基本格式:yyyy-MM-dd 或 yyyy-MM-dd hh:mm:ss，如需查询所支持的所有日期格式，请查看java.text.SimpleDateFormat
     * @return 字符串表示的日期时间
     */
    public static String getDateStr(Date cDate, String cPattern) {
        DateFormat tDateFormat = new SimpleDateFormat(cPattern);
        return tDateFormat.format(cDate);
    }

    /**
     * 返回字符串表示的固定格式日期（yyyy-MM-dd）
     * 
     * @param cDate 日期(java.util.Date)类型对象
    
     * @return 字符串表示的日期，如2012-12-12
     */
    public static String getDateStr(Date cDate) {
        DateFormat tDateFormat = new SimpleDateFormat(DEFAULT_DATE_PATTERN);
        return tDateFormat.format(cDate);
    }

    /**
     * 返回字符串表示的固定格式时间（HH:mm:ss），即使传入当前日期，也只会返回字符串表示的时间。
     * 
     * @param cDate 日期(java.util.Date)类型对象
     * @return 字符串表示的时间，12:12:12
     */
    public static String getTimeStr(Date cDate) {
        return getDateStr(cDate, DEFAULT_TIME_PATTERN);
    }

    /**
     * 取指定日期所在月的第一天的日期
     * 
     * @param cDate 指定的日期
     * @return 指定日期所在月的第一天
     */
    public static Date getFirstDayOfMonth(Date cDate) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.DATE, 1);
        return tCalendar.getTime();
    }

    /**
     * 取指定日期所在月的最后一天的日期
     * 
     * @param cDate 指定的日期
     * @return 指定日期所在月的最后一天
     */
    public static Date getLastDayOfMonth(Date cDate) {
        Date tNextMonth = addMonths(cDate, 1);
        Date tFirstDayOfNextMonth = getFirstDayOfMonth(tNextMonth);
        return addDays(tFirstDayOfNextMonth, -1);
    }

    /**
     * 取指定日期所在年的第一天的日期
     * 
     * @param cDate 指定的日期
     * @return 指定日期所在年的第一天
     */
    public static Date getFirstDayOfYear(Date cDate) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.DATE, 1);
        tCalendar.set(Calendar.MONTH, 0);
        return tCalendar.getTime();
    }

    /**
     * 取指定日期所在年的最后一天的日期
     * 
     * @param cDate 指定的日期
     * @return 指定日期所在月的最后一天
     */
    public static Date getLastDayOfYear(Date cDate) {
        Date tNextMonth = addYears(cDate, 1);
        Date tFirstDayOfNextYear = getFirstDayOfYear(tNextMonth);
        return addDays(tFirstDayOfNextYear, -1);
    }

    /**
     * 取指定日期所在周的指定天的日期
     * 
     * @param cDate 指定的日期
     * @param cDay 指定的天（星期几）
     * @param cFirstDay 一星期的起始天
     * @return 指定周星期日的日期
     */
    public static Date getDayInWeek(Date cDate, int cDay, int cFirstDay) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.setFirstDayOfWeek(cFirstDay);
        tCalendar.set(Calendar.DAY_OF_WEEK, cDay);
        return tCalendar.getTime();
    }

    /**
     * 把Date类型的日期转换成Calendar类型日期对象
     * 
     * @param cDate
     *            Date型的日期
     * @return Calendar型的日期
     */
    public static Calendar getCalendar(Date cDate) {
        Calendar tCalendar = Calendar.getInstance();
        tCalendar.setTime(cDate);
        return tCalendar;
    }

    /**
     * 日期比较（精确到天），date1晚于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @return date1晚于date2，返回true，否则返回false
     */
    public static boolean later(Date cDate1, Date cDate2) {
        boolean tResult = false;
        if (1 == compare(cDate1, cDate2, ACCURACY_DAY)) {
            tResult = true;
        }
        return tResult;
    }

    /**
     * 根据指定规则比较日期，date1晚于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @param cAccuracy
     *            日期精度
     * @return date1晚于date2，返回true，否则返回false
     */
    public static boolean later(Date cDate1, Date cDate2, int cAccuracy) {
        boolean tResult = false;
        if (1 == compare(cDate1, cDate2, cAccuracy)) {
            tResult = true;
        }
        return tResult;
    }
    
    /**
     * 日期比较（精确到天），date1早于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @return date1早于date2，返回true，否则返回false
     */
    public static boolean earlier(Date cDate1, Date cDate2) {
        boolean tResult = false;
        if (-1 == compare(cDate1, cDate2, ACCURACY_DAY)) {
            tResult = true;
        }
        return tResult;
    }

    /**
     * 根据指定规则比较日期，date1早于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @param cAccuracy
     *            日期精度
     * @return date1早于date2，返回true，否则返回false
     */
    public static boolean earlier(Date cDate1, Date cDate2, int cAccuracy) {
        boolean tResult = false;
        if (-1 == compare(cDate1, cDate2, cAccuracy)) {
            tResult = true;
        }
        return tResult;
    }
    
    /**
     * 日期比较（精确到天），date1等于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @return date1等于date2，返回true，否则返回false
     */
    public static boolean equal(Date cDate1, Date cDate2) {
        boolean tResult = false;
        if (0 == compare(cDate1, cDate2, ACCURACY_DAY)) {
            tResult = true;
        }
        return tResult;
    }

    /**
     * 根据指定规则比较日期，date1等于date2
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @param cAccuracy
     *            日期精度
     * @return date1等于date2，返回true，否则返回false
     */
    public static boolean equal(Date cDate1, Date cDate2, int cAccuracy) {
        boolean tResult = false;
        if (0 == compare(cDate1, cDate2, cAccuracy)) {
            tResult = true;
        }
        return tResult;
    }

    /**
     * 根据指定规则，比较日期
     * 
     * @param cDate1
     *            日期1
     * @param cDate2
     *            日期2
     * @param cAccuracy
     *            日期精度
     * @return int型，date1晚，返回1；date1早，返回-1；相等，返回0
     */
    private static int compare(Date cDate1, Date cDate2, int cAccuracy) {
        String tPattern = DEFAULT_DATE_PATTERN;
        switch (cAccuracy) {
        case ACCURACY_YEAR:
            tPattern = ACCURACY_PATTERN_YEAR;
        break;
        case ACCURACY_MONTH:
            tPattern = ACCURACY_PATTERN_MONTH;
        break;
        case ACCURACY_DAY:
            tPattern = ACCURACY_PATTERN_DAY;
        break;
        case ACCURACY_HOUR:
            tPattern = ACCURACY_PATTERN_HOUR;
        break;
        case ACCURACY_MINUTE:
            tPattern = ACCURACY_PATTERN_MINUTE;
        break;
        case ACCURACY_SECOND:
            tPattern = ACCURACY_PATTERN_SECOND;
        break;
        default:
        break;
        }
        Date tFormatedDate1 = transDateFormat(cDate1, tPattern);
        Date tFormatedDate2 = transDateFormat(cDate2, tPattern);
        return tFormatedDate1.compareTo(tFormatedDate2);
    }

    /**
     * 根据指定规则，转化日期，如只取年、取年月等
     * 
     * @param cDate
     *            待转化日期
     * @param cPattern
     *            日期格式
     * @return 转化后的日期
     */
    public static Date transDateFormat(Date cDate, String cPattern) {
        String tDateStr = getDateStr(cDate, cPattern);
        return parseDate(tDateStr, cPattern);
    }

    /**
     * 返回时定时间的年
     * 
     * @param cDate
     *            日期
     * @return String型的年
     */
    public static String getYear(Date cDate) {
        return getDateStr(cDate, SINGLE_YEAR);
    }

    /**
     * 返回时定时间的月
     * 
     * @param cDate
     *            日期
     * @return String型的月
     */
    public static String getMonth(Date cDate) {
        return getDateStr(cDate, SINGLE_MONTH);
    }

    /**
     * 返回时定时间的日
     * 
     * @param cDate
     *            日期
     * @return String型的日
     */
    public static String getDay(Date cDate) {
        return getDateStr(cDate, SINGLE_DAY);
    }

    /**
     * 返回时定时间的小时
     * 
     * @param cDate
     *            日期
     * @return String型的小时
     */
    public static String getHour(Date cDate) {
        return getDateStr(cDate, SINGLE_HOUR);
    }

    /**
     * 返回时定时间的分
     * 
     * @param cDate
     *            日期
     * @return String型的分
     */
    public static String getMinute(Date cDate) {
        return getDateStr(cDate, SINGLE_MINUTE);
    }

    /**
     * 返回时定时间的秒
     * 
     * @param cDate
     *            日期
     * @return String型的秒
     */
    public static String getSecond(Date cDate) {
        return getDateStr(cDate, SINGLE_SECOND);
    }

    /**
     * 将时间日期变量的年份变为指定年, 如果日期不存在，则向后一天，如20102月
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定年
     * @return 修改后的日期变量
     */
    public static Date setYear(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.YEAR, cAmount);
        return tCalendar.getTime();
    }

    /**
     * 将时间日期变量的月份变为指定月
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定月
     * @return 修改后的日期变量
     */
    public static Date setMonth(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.MONTH, cAmount - 1);
        return tCalendar.getTime();
    }

    /**
     * 将时间日期变量的年份变为指定日
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定日
     * @return 修改后的日期变量
     */
    public static Date setDay(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.DAY_OF_MONTH, cAmount);
        return tCalendar.getTime();
    }

    /**
     * 将时间日期变量的小时变为指定时
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定时
     * @return 修改后的日期变量
     */
    public static Date setHour(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.HOUR_OF_DAY, cAmount);
        return tCalendar.getTime();
    }

    /**
     * 将时间日期变量的分钟变为指定分
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定分
     * @return 修改后的日期变量
     */
    public static Date setMinute(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.MINUTE, cAmount);
        return tCalendar.getTime();
    }

    /**
     * 将时间日期变量的秒变为指定秒
     * 
     * @param cDate
     *            日期时间变量
     * @param cAmount
     *            指定秒
     * @return 修改后的日期变量
     */
    public static Date setSecond(Date cDate, int cAmount) {
        Calendar tCalendar = getCalendar(cDate);
        tCalendar.set(Calendar.SECOND, cAmount);
        return tCalendar.getTime();
    }

    /**
     * 根据制定单位，计算两个日期之间的天数差
     * 
     * @param cA
     *            时间点1
     * @param cB
     *            时间点2
     * @return 时间差
     */
    public static int getDateDistance(Date cA, Date cB) {
        return getDateDistance(cA, cB, ACCURACY_DAY);
    }

    /**
     * 根据制定单位，计算两个日期之间的差
     * 
     * @param cA
     *            时间点1
     * @param cB
     *            时间点2
     * @param cUnit
     *            时间单位
     * @return 时间差
     */
    public static int getDateDistance(Date cA, Date cB, int cUnit) {
        int tResult = 0;
        if ((null != cA && null != cB) && (ACCURACY_SECOND <= cUnit && ACCURACY_DAY >= cUnit)) {
            String tPattern = null;
            switch (cUnit) {
            case ACCURACY_DAY:
                tPattern = ACCURACY_PATTERN_DAY;
            break;
            case ACCURACY_HOUR:
                tPattern = ACCURACY_PATTERN_HOUR;
            break;
            case ACCURACY_MINUTE:
                tPattern = ACCURACY_PATTERN_MINUTE;
            break;
            case ACCURACY_SECOND:
                tPattern = ACCURACY_PATTERN_SECOND;
            break;
            default:
            break;
            }
            Date tStartDate = transDateFormat(1 == cA.compareTo(cB) ? cB : cA, tPattern);
            Date tEndDate = transDateFormat(1 == cA.compareTo(cB) ? cA : cB, tPattern);
            tResult = getDistanceByUnit(tStartDate, tEndDate, cUnit);
        }
        return tResult;
    }

    /**
     * 内部方法，计算时间点的差距
     * 
     * @param cStartDate
     *            起始时间
     * @param cEndDate
     *            终止时间
     * @param cUnit
     *            时间单位
     * @return 时间差
     */
    private static int getDistanceByUnit(Date cStartDate, Date cEndDate, int cUnit) {
        int tResult = 0;
        long tMillisecondPerUnit = MILLISECONDS_PER_DAY;
        switch (cUnit) {
        case ACCURACY_HOUR:
            tMillisecondPerUnit = MILLISECONDS_PER_HOUR;
        break;
        case ACCURACY_MINUTE:
            tMillisecondPerUnit = MILLISECONDS_PER_MINUTE;
        break;
        case ACCURACY_SECOND:
            tMillisecondPerUnit = MILLISECONDS_PER_SECOND;
        break;
        default:
        break;
        }
        long tStart = cStartDate.getTime();
        long tEnd = cEndDate.getTime();
        long tDistance = tEnd - tStart;
        tResult = Integer.valueOf((tDistance / tMillisecondPerUnit) + "");
        return tResult;
    }

    /**
     * 返回指定日期是当年的第几周
     * 
     * @param cDate
     *            指定日期
     * @return 周数（从1开始）
     */
    public static int getWeekOfYear(Date cDate) {
        return getCalendar(cDate).get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取指定日期是星期几
     * 
     * @param cDate
     *            指定日期
     * @return 星期日--1; 星期一--2; 星期二--3; 星期三--4; 星期四--5; 星期五--6; 星期六--7;
     */
    public static int getWeekOfDate(Date cDate) {
        return getCalendar(cDate).get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 判断指定年份日期的年份是否为闰年
     * 
     * @param cDate
     *      日期
     * @return 闰年ture，非闰年false
     */
    public static boolean isLeapYear(Date cDate) {
        int tYear = getCalendar(cDate).get(Calendar.YEAR);
        return isLeapYear(tYear);
    }

    /**
     * 判断指定年份日期的年份是否为闰年
     * 
     * @param cYear
     *            年份数字
     * @return 闰年ture，非闰年false
     */
    public static boolean isLeapYear(int cYear) {
        if ((cYear % 400) == 0) {
            return true;
        } else if ((cYear % 4) == 0) {
            if ((cYear % 100) == 0) {
                return false;
            } else {
                return true;
            }
        } else {
            return false;
        }
    }

    /**
     * 校验日期数据（校验输入值是否为指定的日期格式）
     * 
     * @param cStrDate
     *            要校验的日期
     * @param cStrFormat
     *            日期格式
     * @return true/false （符合/不符合）
     */
    public static boolean checkDate(String cStrDate, String cStrFormat) {
        Date tDate = null;
        if ((cStrDate != null) && (cStrDate.trim().length() != 0)) {
            DateFormat tMyDateFmt = new SimpleDateFormat(cStrFormat);
            try {
                tDate = tMyDateFmt.parse(cStrDate);

                if (!cStrDate.equals(tMyDateFmt.format(tDate))) {
                    tDate = null;
                    return false;
                }
            } catch (ParseException e) {
                tDate = null;
                return false;
            }
        }
        return true;
    }

    /**
     * 
     * 获取第二天的时间
     * @return 日期类型（java.util.Date）
     */
    public static Date getTomorrow() {
        return DateUtil.addDays(getCurrentDate(), 1);
    }

    /**
     * 根据出生日期获取当前年龄
     * @param cBirthDate
     * @return 年龄
     * @history 
     *   1 edit  by chihouliang 2016年6月30日  修改代码规范，重写方法算法
     */
    public static Integer getAge(Date cBirthDate) {

        if (cBirthDate == null) {
            throw new RuntimeException("出生日期不能为null");
        }

        Calendar tNowTime = Calendar.getInstance();//现在的时间
        Calendar tBirthDateTime = Calendar.getInstance();//出生时间
        tBirthDateTime.setTime(cBirthDate);

        if (tBirthDateTime.after(tNowTime)) {
            throw new RuntimeException("出生日期不能晚于现在时间");
        }

        int tAge = 0;//年龄
        
        tAge = tNowTime.get(Calendar.YEAR) - tBirthDateTime.get(Calendar.YEAR);//年龄
        /*
         * 如果现在的月份小于生日月份，年龄减一
         */
        if (tNowTime.get(Calendar.DAY_OF_YEAR) < tBirthDateTime.get(Calendar.DAY_OF_YEAR)) {
            tAge -= 1;
        }

        return tAge;
    }
}